Redes Neuronales

Introduction to Artificial Neural Networks (ANN)

Artificial Neural Networks (ANN) are computing systems inspired by the biological neural networks of animal brains. These models are designed to simulate the way the human brain processes information, making them exceptionally good at modeling and solving complex problems by learning from data.

Applications of ANNs

ANNs are applied in a wide range of real-world scenarios, some of which include:

• Netflix content recommendation: Uses ANNs to analyze your viewing history and preferences to recommend movies and shows you’re likely to enjoy.
• Instagram feed: Employs deep learning algorithms to personalize your feed, showing you content that is more relevant to your interests.
• Handwritten digit recognition: ANNs can identify and classify handwritten numbers, a technology used in document digitization and character recognition.
• FaceID technology: Utilizes advanced ANNs for secure and accurate facial recognition, allowing you to unlock your device by simply looking at it.

These examples demonstrate the versatility and the ability of ANNs to learn from large datasets and perform tasks that would require human intelligence.

Exercise 1: Did I Pass the Subject?

This exercise focuses on using an ANN to predict whether a student has passed a subject based on their academic features, such as grades obtained in assignments, midterm exams, and class attendance.

1. Install Packages and Call Libraries

Before we start working with artificial neural networks in R, it’s crucial to have the neuralnet package installed and loaded. This package allows us to efficiently train and simulate artificial neural networks in R with a relatively straightforward syntax. The following code chunk first checks if the neuralnet package is installed, installing it if necessary. Then, it loads the package using library(neuralnet), enabling us to access its functions and use them in our analysis.

Ensure you have an active internet connection if you need to install the package, as install.packages will download the package from CRAN.

# install.packages("dplyr")
# install.packages("neuralnet")
library(dplyr)

## 
## Attaching package: 'dplyr'

## The following objects are masked from 'package:stats':
## 
##     filter, lag

## The following objects are masked from 'package:base':
## 
##     intersect, setdiff, setequal, union

library(neuralnet)

## 
## Attaching package: 'neuralnet'

## The following object is masked from 'package:dplyr':
## 
##     compute

2. Obtain Data

We are constructing a data frame named df that contains three columns: exam, proyect, and status. Each of these columns represents different aspects of a dataset that could be related to student assessments or project evaluations:

• The exam column contains numeric scores or values associated with exams, with each entry representing a different individual or instance.

• The proyect column (presumably intended to spell “project”) includes scores or values related to projects. Like the exam column, each entry here pertains to a different individual or instance.

• The status column uses binary values (1 or 0) to indicate a particular state or condition for each entry. This could represent a pass/fail status, completion, or any other binary indicator relevant to the context of the data.

The code below combines these vectors into a single data frame, providing a structured and tabular representation of the data for further analysis or visualization.

exam<-c(20,10,30,20,80,30)
proyect<-c(90,20,40,50,50,80)
status<-c(1,0,0,0,0,1)

df<-data.frame(exam,proyect,status)

3. Generate Neural Network

We’re applying a neural network model to predict the status based on exam and proyect scores using the neuralnet package. This model helps us understand the relationship between exam/project scores and their status outcomes. After training the model with nn1 <- neuralnet(status ~., data=df), we visualize it using plot(nn1, rep="best") to inspect the network structure and how inputs are related to the prediction.

nn1 <- neuralnet(status ~., data=df)
plot(nn1, rep="best")

4. Predict Results

Now that our neural network model is trained, we proceed to evaluate its predictive performance using a new set of exam and project scores. This step is essential for assessing the model’s ability to generalize and make accurate predictions on data it hasn’t seen before. By inputting these new scores into the model, we aim to predict their corresponding statuses, providing insights into how well our model can apply learned patterns to real-world or hypothetical scenarios. This evaluation phase is crucial for understanding the practical applicability of our neural network in predicting outcomes based on exam and project performances.

exam_test<-c(30,40,85)
proyect_test<-c(85,50,40)
test1 <- data_frame(exam_test,proyect_test)

## Warning: `data_frame()` was deprecated in tibble 1.1.0.
## ℹ Please use `tibble()` instead.
## This warning is displayed once every 8 hours.
## Call `lifecycle::last_lifecycle_warnings()` to see where this warning was
## generated.

prediction <- compute(nn1,test1)

prediction$net.result

##             [,1]
## [1,]  1.01126893
## [2,]  0.01946212
## [3,] -0.01891719

1. Install Packages and Call Libraries

Before diving into our analysis, it’s crucial to ensure that all necessary packages are installed and loaded into our R environment. This step lays the groundwork for a smooth analysis process, allowing us to utilize various functions and tools provided by these packages. Specifically, we focus on two packages:

• readr: Facilitates efficient reading of rectangular data, such as CSV files. Its fast and friendly syntax makes it a go-to choice for data import in R.
• caret: Stands for Classification And REgression Training. This package provides a comprehensive suite of tools to create complex predictive models. It simplifies the process of training and tuning machine learning models, making it invaluable for predictive analytics.

By loading these libraries, we ensure that our R session is equipped with the necessary tools for data importation, preprocessing, and advanced modeling techniques.

# install.packages("readr")
# install.packages("caret")
library(readr)
library(caret)

2. Obtain Data

After setting up our environment with the necessary libraries, our next step involves loading and preparing the dataset for analysis. We’re focusing on a dataset named cancer_de_mama.csv, which includes data pertinent to breast cancer diagnosis. The preparation process involves several key steps to ensure the data is suitable for training a machine learning model:

• Loading the Dataset: We use the read_csv function from the readr package to load the cancer_de_mama.csv file. This function is optimized for fast and efficient loading of CSV files into R.

• Encoding the Diagnosis: The dataset includes a diagnosis column with categorical values (M for malignant, B for benign). We convert these into binary numeric values (1 for malignant, 0 for benign) to facilitate the modeling process. This encoding simplifies the use of algorithms that require numerical input.

• Splitting the Data: To evaluate our model’s performance accurately, we split the dataset into training and testing sets. Using the createDataPartition function from the caret package, we allocate 75% of the data for training and reserve 25% for testing. This split is based on the diagnosis column to ensure that both sets are representative of the overall dataset.

• Reproducibility: We set a seed before splitting the data to ensure that our results are reproducible. This step is crucial for scientific rigor and allows others to replicate our analysis exactly.

The following code snippet illustrates these steps:

breast_cancer <- read_csv("cancer_de_mama.csv")
breast_cancer$diagnosis <- ifelse(breast_cancer$diagnosis == "M", 1, 0)

# Create indices for a 75% train and 25% test split
set.seed(123) # Setting seed for reproducibility
trainIndex <- createDataPartition(breast_cancer$diagnosis, p = 0.75, 
                                  list = FALSE, 
                                  times = 1)

# Split the data into training and testing sets
trainSet <- breast_cancer[trainIndex, ]
testSet <- breast_cancer[-trainIndex, ]

head(breast_cancer)

## # A tibble: 6 × 31
##   diagnosis radius_mean texture_mean perimeter_mean area_mean smoothness_mean
##       <dbl>       <dbl>        <dbl>          <dbl>     <dbl>           <dbl>
## 1         1        18.0         10.4          123.      1001           0.118 
## 2         1        20.6         17.8          133.      1326           0.0847
## 3         1        19.7         21.2          130       1203           0.110 
## 4         1        11.4         20.4           77.6      386.          0.142 
## 5         1        20.3         14.3          135.      1297           0.100 
## 6         1        12.4         15.7           82.6      477.          0.128 
## # ℹ 25 more variables: compactness_mean <dbl>, concavity_mean <dbl>,
## #   `concave points_mean` <dbl>, symmetry_mean <dbl>,
## #   fractal_dimension_mean <dbl>, radius_se <dbl>, texture_se <dbl>,
## #   perimeter_se <dbl>, area_se <dbl>, smoothness_se <dbl>,
## #   compactness_se <dbl>, concavity_se <dbl>, `concave points_se` <dbl>,
## #   symmetry_se <dbl>, fractal_dimension_se <dbl>, radius_worst <dbl>,
## #   texture_worst <dbl>, perimeter_worst <dbl>, area_worst <dbl>, …

3. Clean Data

After splitting the breast_cancer dataset into training and testing sets, further refinements are made to ensure smooth model training and evaluation:

• Standardizing Variable Names: To prevent potential issues with variable names that might not conform to R’s variable naming conventions (such as spaces or special characters), we use make.names with the unique = TRUE parameter. This function modifies the names in both training and testing datasets to ensure they are valid R identifiers and unique. This step is crucial for avoiding errors during model training and evaluation.

• Preparing a Blind Testing Set: To evaluate the model’s predictive performance objectively, we create a ‘blind’ testing set. This version of the testing set excludes the diagnosis column, which is the outcome variable our model aims to predict. The absence of this variable ensures that our model predictions are made without access to the true outcomes, mimicking a real-world scenario where the model would be used to predict unknown cases.

The code modifications applied to the variable names and the preparation of the blind testing set are foundational for the subsequent modeling steps. They help in ensuring that our analysis pipeline is robust and that the evaluation of the model’s performance is as realistic as possible.

names(trainSet) <- make.names(names(trainSet), unique = TRUE)

names(testSet) <- make.names(names(trainSet), unique = TRUE)
testSetBlind <- subset(testSet, select = -diagnosis)

4. Generate Neural Network

With our data preprocessed and split into training and testing sets, we proceed to train a neural network model. Our objective is to predict the binary diagnosis outcome (malignant or benign) based on a range of input features. The model is configured with a single hidden layer consisting of five neurons, a setup aimed at capturing the underlying complexities in the data without overly complicating the model.

Following the model training, we visualize the neural network. This visualization serves as a crucial step for understanding the model’s structure, including how inputs are processed through hidden layers to produce the final prediction. It provides us with a graphical representation of the model, showcasing the neurons, layers, and their interconnections.

This trained model and its visualization allow us to closely examine the neural network’s architecture and better understand the factors influencing its predictions. It sets the stage for the next steps, where we will assess the model’s performance on unseen data and gauge its predictive accuracy.

nn2 <- neuralnet(diagnosis ~ ., data=trainSet, hidden=c(5), linear.output=FALSE)
plot(nn2, rep="best")

5. Predict Results

After predicting the outcomes for our blind testing set using the neural network model, we proceed to assess the model’s performance through several key metrics: accuracy, recall, and specificity. These metrics collectively offer a comprehensive view of the model’s predictive capabilities:

• Accuracy provides a high-level overview of the model’s overall performance, indicating how often it predicts correctly.
• Recall is especially important in medical diagnostics, as it measures the model’s ability to identify all relevant cases of malignancy.
• Specificity complements recall by assessing the model’s proficiency in correctly identifying benign cases, thus avoiding unnecessary alarm.

The computation of these metrics is based on a confusion matrix, which contrasts the predicted labels against the actual labels from the testing set. This analysis yields valuable insights into the model’s strengths and areas for improvement, especially in the context of breast cancer diagnosis where the balance between sensitivity and specificity is critical.

prediction <- compute(nn2,testSetBlind)

predicted_labels <- ifelse(prediction$net.result > 0.5, 1, 0)
true_labels <- testSet$diagnosis
conf_matrix <- table(Predicted = predicted_labels, Actual = true_labels)

# Accuracy Metrics
accuracy <- sum(diag(conf_matrix)) / sum(conf_matrix)
recall <- conf_matrix[2,2] / sum(conf_matrix[2,])
specificity <- conf_matrix[1,1] / sum(conf_matrix[1,])

cat("Accuracy:", accuracy, "\n")

## Accuracy: 0.9859155

cat("Recall:", recall, "\n")

## Recall: 1

cat("Specificity:", specificity, "\n")

## Specificity: 0.9753086